package com.itfenghuang.day11;


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//多线程
public class A02_Thread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         *  1.
         *      举个例子
         *          如果将右手比作cpu,鼠标,水,烟 是三个软件 cpu高速在它们之间切换
         *      两点:
         *          多线程是同时执行多个程序
         *          多线程需要硬件支持
         *
         *  2.
         *      并行: 同一时刻,多个指令在多个cpu上同时执行
         *      并发: 同一时刻,有多个指令在单个cpu上交替执行
         *      进程: 正在运行的程序
         *      线程: 进程中一条执行路径
         *      单线程; 一个进程只有一条执行路径,则称为单线程程序
         *      多线程: 一个进程中如有多条执行路径,则称为多线程程序
         *
         *  3. 实现多线程的方式之一:
         *        继承Thread类:  java中的线程类
         *        实现步骤
         *              1). 自定义类继承thread
         *              2). 在自定义类中重写run()方法
         *              3). 创建自定义类对象,在测试类中
         *              4.) 启动线程
         *          run() 方法:  就是当前线程要执行的任务
         *          start() 方法:  使此线程开启开始执行,jvm自动调用run() 方法
         *      为什么要重写run()方法?
         *      run方法是当前线程要执行的任务,如果不重写run方法,启动新的线程没有任何意义
         *      调用run()方法和start()方法区别
         *          1.直接通过对象名调用run()方法,主线程(main)执行
         *          2.调用start()方法 开启一个线程,让该线程去执行线程任务
         *
         *  4.实现多线程方式之二:
         *         实现Runnable接口
         *         实现步骤
         *              1). 自定义一个类实现 runnable接口
         *              2). 在自定义类中,重写run方法
         *              3(. 测试类中,创建自定义类对象
         *              4). 创建thread对象,将自定义对象通过构造方法传进来
         *              5). 开启线程
         *
         *  5.实现多线程方式之三
         *          实现Callable接口
         *          实行步骤
         *              1). 自定义类实现Callable接口,重写call方法
         *              2). 创建自定义类对象
         *              3). 创建future的实现类futureTask对象,
         *                   将自定义类通过构造方法传递过去
         *              4). 创建thread类,将futureTask对象通过构造方法传递过去
         *              5). 开启线程
         *
         * 2022.1.21 线程池的七大参数
         */
        //创建自定义类对象
        MyThread mt = new MyThread();
        //启动
        mt.start();


        //实现多线程方式之二
        MyRunnable mr = new MyRunnable();
        Thread thread = new Thread(mr);
        thread.start();

        //实现多线程方式之三
        MyCallable mc = new MyCallable();
        FutureTask<Object> ft = new FutureTask<Object>(mc);
        //创建thread对象
        Thread thread1 = new Thread(ft);
        thread1.start();
        //使用futuretask对象获取线程的返回值
        System.out.println(ft.get());
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程正在执行"+i);
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("实现多线程方式之二"+i);
        }
    }
}
class MyCallable implements Callable<Object>{

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 2000; i++) {
            System.out.println("飞飞飞飞飞"+i);
        }
        return "起飞咯";
    }
}